﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Net;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Remoting.Messaging;
using System.IO;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading;
using System.Reflection;
namespace Cliente
{
    public partial class Client : Form
    {
        #region Variabili
        private Socket chat_socket; // socket
        private Socket frame_socket; // socket frame
        private Socket clipboard_socket; // socket clipboard
        private string username; // il mio username
        private string password; // la mia password
        private string indirizzo; // nome server a cui connettermi
        private int porta; // numero porta del server 
        Bitmap immagine_no_mouse; // mantiene l'immagine senza il mouse;
        string path = "C:\\Temp\\"; // Cartella temporanea nella quale posizionare i file scaricati dalla clipboard
        WaitForm progressform;
        #endregion

        #region Costruttore
        /// <summary>
        /// Costruttore della classe Client
        /// </summary>
        public Client()
        {
            InitializeComponent();

            
                ChatBrowser.Navigate("About:blank"); //vado alla pagina di diefault bianca
                ChatBrowser.Document.Write(Properties.Resources.page_style); // modifico la pagina di default con quella del page style
                this.progressform = new WaitForm();
                ConnectionButton();
                if (!Directory.Exists(path))
                {
                    Directory.CreateDirectory(path);
                }
            
        }
        #endregion

        #region Network

        public delegate Messaggio RiceviMsgDelegate();
        public void ricevi_chat(AsyncCallback callback)
        {
            try
            {
                RiceviMsgDelegate d = new RiceviMsgDelegate(RiceviMsgChat);
                IAsyncResult result = d.BeginInvoke(callback, this.chat_socket);
            }
            catch (RiceviMsgException)
            {
               
                DisabilitaInterfaccia("");
            }
        }

        public void ricevi_frame(AsyncCallback callback)
        {
            try
            {
                RiceviMsgDelegate d2 = new RiceviMsgDelegate(RiceviMsgFrame);
                d2.BeginInvoke(new AsyncCallback(gestisciReceive_Frame), this.frame_socket);
            }
            catch (RiceviMsgException)
            {
          
                DisabilitaInterfaccia("");
            }
      }
        public void ricevi_clipboard(AsyncCallback callback)
        {
            try
            {

                RiceviMsgDelegate d3 = new RiceviMsgDelegate(RiceviMsgClipboard);
                d3.BeginInvoke(new AsyncCallback(gestisciReceive_Clipboard), this.clipboard_socket);
            }
            catch (RiceviMsgException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("");
            }
        }
        /// <summary>
        /// Questa funzione è la callback che è chiamata quando il messaggio è stato ricevuto
        /// Si occupa di restuire un messaggio oppure di disabilitare il cliente poiché si è verificato un errore sulla rete
        /// </summary>
        /// <returns></returns>
        private Messaggio RiceviMsgChat()
        {
            try
            {
                BinaryFormatter formatter = new BinaryFormatter();
                NetworkStream stream = new NetworkStream(this.chat_socket);
                Messaggio m = (Messaggio)formatter.Deserialize(stream);
                return m;
            }
 
            catch (System.IO.IOException)
            {
                return null;
            }
            catch (SerializationException)
            {
                return null;
            }
        }
        /// <summary>
        /// Funzione che si occupa di ricevere il messaggio arrivatogli e a seconda del tipo di messaggio gestirlo
        /// </summary>
        /// <param name="result"></param>
        private void gestisciReceive_Chat(IAsyncResult result)
        {
            try
            {
                AsyncResult r = (AsyncResult)result;
                RiceviMsgDelegate d = (RiceviMsgDelegate)r.AsyncDelegate;
                Messaggio m = (Messaggio)d.EndInvoke(r);
                Socket s = (Socket)r.AsyncState;
                if (m == null)
                {
                    this.chat_socket.Close();
                    DisabilitaInterfaccia("");
                }
                else
                {
                    if (m.isClipboardAvailable) // è un comando e il server lo invia sulla chat
                    {
                        AggiornaButtonClipBoard();
                    }
                    else // è un messaggio della chat
                    {
                        AggiornaChat(m.Nome, m.Text);
                    }

                    ricevi_chat(gestisciReceive_Chat);
                }
            }
            catch (System.IO.IOException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("");
            }
            catch (SerializationException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("");
            }
            catch (RiceviMsgException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("");
            }
        }


        /// <summary>
        /// Questa funzione è la callback che è chiamata quando il messaggio è stato ricevuto
        /// Si occupa di restuire un messaggio oppure di disabilitare il cliente poiché si è verificato un errore sulla rete
        /// </summary>
        /// <returns></returns>
        private Messaggio RiceviMsgFrame()
        {
            try
            {
                BinaryFormatter formatter = new BinaryFormatter();
                NetworkStream stream = new NetworkStream(this.frame_socket);
                Messaggio m = (Messaggio)formatter.Deserialize(stream);
                return m;
            }
            catch (System.IO.IOException)
            {
                return null;
            }
            catch (SerializationException)
            {
                return null;
            }
           
        }
        /// <summary>
        /// Funzione che si occupa di ricevere il messaggio arrivatogli e a seconda del tipo di messaggio gestirlo
        /// </summary>
        /// <param name="result"></param>
        private void gestisciReceive_Frame(IAsyncResult result)
        {
            try
            {
                AsyncResult r = (AsyncResult)result;
                RiceviMsgDelegate d = (RiceviMsgDelegate)r.AsyncDelegate;
                Messaggio m = (Messaggio)d.EndInvoke(r);

                Socket s = (Socket)r.AsyncState;
                if (m == null)
                {
                    this.frame_socket.Close();
                    DisabilitaInterfaccia("");
                }
                else
                {
                    if (m.isFrame) // codice di gestione di invio dei vari frame
                    {
                        if (m.isPart) // porzione della picture
                        {

                            AggiornaPicture(m.Frame, m.Part, m.MousePos);
                        }
                        else // picuture completa
                        {
                            AggiornaPicture(m, m.MousePos);
                        }
                    }
                    ricevi_frame(gestisciReceive_Frame);
                }
            }
            catch (System.IO.IOException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("");
            }
            catch (SerializationException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("");
            }
            catch (RiceviMsgException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("");
            }
        }

        /// <summary>
        /// Questa funzione è la callback che è chiamata quando il messaggio è stato ricevuto
        /// Si occupa di restuire un messaggio oppure di disabilitare il cliente poiché si è verificato un errore sulla rete
        /// </summary>
        /// <returns></returns>
        private Messaggio RiceviMsgClipboard()
        {
            try
            {
                BinaryFormatter formatter = new BinaryFormatter();
                NetworkStream stream = new NetworkStream(this.clipboard_socket);
                Messaggio m = (Messaggio)formatter.Deserialize(stream);
                return m;
            }
            
            catch (System.IO.IOException)
            {
                return null;
            }
            catch (SerializationException)
            {
                return null;
            }
            
        }
        /// <summary>
        /// Funzione che si occupa di ricevere il messaggio arrivatogli e a seconda del tipo di messaggio gestirlo
        /// </summary>
        /// <param name="result"></param>
        private void gestisciReceive_Clipboard(IAsyncResult result)
        {
            try
            {
                AsyncResult r = (AsyncResult)result;
                RiceviMsgDelegate d = (RiceviMsgDelegate)r.AsyncDelegate;
                Messaggio m = (Messaggio)d.EndInvoke(r);
                Socket s = (Socket)r.AsyncState;
                if (m == null)
                {
                    this.clipboard_socket.Close();
                    DisabilitaInterfaccia("");
                }
                else
                {
                    if (m.isClipboardAvailable) // il server ha condiviso la clipboard
                    {
                        AggiornaButtonClipBoard();
                    }
                    else if (m.isClipboardObject) // Il server mi ha mandato il contenuto della clipboard
                    {
                        GestioneClipBoard(m);
                    }
                    ricevi_clipboard(gestisciReceive_Clipboard);
                }
            }
            catch (System.IO.IOException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("");
            }
            catch (SerializationException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("");
            }
            catch (RiceviMsgException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("");
            }
        }

        /// <summary>
        ///questa funzione connette e autentica il socket se fallisce lancia una eccezione
        /// </summary>
        private void connetti() 
        {
            try
            {
                this.chat_socket.Connect(this.indirizzo, this.porta); // se non ci riece mi da una eccezione
                Messaggio auteticazione = new Messaggio(this.username, this.password, "hello");
                NetworkStream stream = new NetworkStream(this.chat_socket);
                BinaryFormatter bin = new BinaryFormatter();
                bin.Serialize(stream, auteticazione);
                stream.Close();
                ricevi_chat(new AsyncCallback(GestisciAutenticazione));
            }
            catch (Exception)
            {
                this.DisabilitaInterfaccia("Connessione non riuscita verifica indirizzo e porta del server");
            }
            ChiudiWaitForm();
        }

        private delegate void ChiudiWaitFormDelegate();
        private void ChiudiWaitForm()
        {
            if (this.InvokeRequired)
            {
                IAsyncResult r = this.BeginInvoke(new ChiudiWaitFormDelegate(ChiudiWaitForm));
                this.EndInvoke(r);
            }
            else
            {
                this.Enabled = true;
                this.progressform.Visible = false;
            }
        }
        /// <summary>
        /// Come la receive ma se ci sono errori aspetta avvisa il l'utente che è fallita l'autenticazione
        /// </summary>
        /// <param name="result"></param>
        private void GestisciAutenticazione(IAsyncResult result)
        {
            try
            {
                AsyncResult r = (AsyncResult)result;
                RiceviMsgDelegate d = (RiceviMsgDelegate)r.AsyncDelegate;
                Messaggio m = (Messaggio)d.EndInvoke(r);
                
                Socket s = (Socket)r.AsyncState;
                if (m == null)
                {
                    this.chat_socket.Close();
                    DisabilitaInterfaccia("Autenticazione fallita controlla nome utente e password");
                }
                else
                {
                    AggiornaChat(m.Nome, m.Text); // mi scrive il messaggio di benvenuto
                    AbilitaInterfaccia();
                    this.frame_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    this.clipboard_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    this.frame_socket.Connect(this.indirizzo, this.porta);
                    this.clipboard_socket.Connect(this.indirizzo, this.porta);
                    ricevi_chat(gestisciReceive_Chat);
                    ricevi_frame(gestisciReceive_Frame);
                    ricevi_clipboard(gestisciReceive_Clipboard);
                }
            }
            catch (System.IO.IOException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("Autenticazione fallita controlla nome utente e password");
            }
            catch (SerializationException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("Autenticazione fallita controlla nome utente e password");
            }
            catch (RiceviMsgException)
            {
                this.chat_socket.Close();
                DisabilitaInterfaccia("Autenticazione fallita controlla nome utente e password");
            }
        } // uguale alla gestisci receive, ma se fallisce vuol dire che il server non mi ha autenticato
        private void invia_msg(Messaggio m) // l'invio è sincrono
        {
            NetworkStream stream = new NetworkStream(this.chat_socket);
            BinaryFormatter bin = new BinaryFormatter();
            bin.Serialize(stream, m);
            stream.Close();
        }

        #endregion

        #region GestioneClipboard

        delegate void GestioneClipboardDelegate(Messaggio m);
        /// <summary>
        /// Gestisce un messaggio di tipo clipboard, solo con formati supportati e lo copia nella clipboard locale 
        /// /// </summary>
        /// <param name="m">Il messaggio che contiene i vari dati</param>
        private void GestioneClipBoard(Messaggio m)
        {

            if (this.InvokeRequired)
            {
                IAsyncResult r = BeginInvoke(new GestioneClipboardDelegate(GestioneClipBoard),m);
                EndInvoke(r);
            }
            else
            {
                string[] formati_disponibili = m.FormatiClipboard;
                Object[] dato = m.OggettiClipboard;
                int i = 0;
                foreach (string formato in formati_disponibili)
                {
                    if (formato == "file")
                    {
                        FileStream fs = File.Open(path + m.FileName, FileMode.Create, FileAccess.Write, FileShare.Write);
                        byte[] vett = (byte[])dato[0];
                        fs.Write(vett, 0, vett.Length);
                        fs.Close();
                        System.Collections.Specialized.StringCollection collezione = new System.Collections.Specialized.StringCollection();
                        collezione.Add(path + m.FileName);
                        Clipboard.SetFileDropList(collezione);
                        AggiornaChat("Admin", "File " +m.FileName + " copiato nella clipboard");
                        break;
                    }
                    if (formato == DataFormats.Bitmap || formato == DataFormats.Text || formato == DataFormats.Dib || formato == DataFormats.Tiff)
                    {
                        Clipboard.SetData(formato, dato[i]);
                        AggiornaChat("Admin", "Messaggio copiato nella clipboard");
                        break;
                    }
                    i++;
                }
                this.downloadCLipboradToolStripMenuItem.Enabled = false;
                if (i >= formati_disponibili.Length)
                {
                    AggiornaChat("Admin", "Formato Clipboard non supportato");
                }
            }
           
        }
        delegate void AggiornaButtonClipBoardDelegate();
        
        /// <summary>
        /// Abilita il bottone che aggiorna la clipboard
        /// </summary>
        private void AggiornaButtonClipBoard()
        {
            if (this.InvokeRequired)
            {
                IAsyncResult r = BeginInvoke(new AggiornaButtonClipBoardDelegate(AggiornaButtonClipBoard));
                EndInvoke(r);
            }
            else
            {
                this.downloadCLipboradToolStripMenuItem.Enabled = true;
                AggiornaChat("Admin", "Il server ha condiviso il contenuto della Clipboard");
            }
        }

        #endregion

        #region AggiornaPicture
        delegate void AggiornaPictureDelegate(Messaggio m , Point mouse);
        /// <summary>
        /// Disegna nella picture box il contenuto del messaggio e la posizione del mouse 
        /// </summary>
        /// <param name="m"> Contenuto messaggio </param>
        /// <param name="mouse">Posizione del mouse</param>
        private void AggiornaPicture(Messaggio m,Point mouse)
        {
            if (this.InvokeRequired)
            {
               IAsyncResult r =  BeginInvoke(new AggiornaPictureDelegate(AggiornaPicture), m,mouse);
               EndInvoke(r);
            }
            else
            {
                if (this.immagine_no_mouse!= null)
                    this.immagine_no_mouse.Dispose();
                this.immagine_no_mouse = new Bitmap(m.Frame);

                if (this.pictureBox1.Image != null)
                    this.pictureBox1.Image.Dispose();
                this.pictureBox1.Image = ToolImmagini.DisegnaMouse(this.immagine_no_mouse, mouse);
                pictureBox1.SizeMode = PictureBoxSizeMode.Zoom;
            }
          }
        delegate void AggiornaPictureDelegate3(Bitmap m, Rectangle part, Point mouse);
        private void AggiornaPicture(Bitmap image, Rectangle part, Point mouse)
        {
            try
            {
                if (this.InvokeRequired)
                {
                    IAsyncResult r = BeginInvoke(new AggiornaPictureDelegate3(AggiornaPicture), image, part, mouse);
                    EndInvoke(r);
                }
                else
                {
                    this.immagine_no_mouse = ToolImmagini.CopyOnbackground(this.immagine_no_mouse, image, part);
                    if (this.pictureBox1.Image != null)
                        this.pictureBox1.Image.Dispose();
                    this.pictureBox1.Image = ToolImmagini.DisegnaMouse(this.immagine_no_mouse, mouse);
                }
            }
            catch (Exception)
            {

            }
        }
        #endregion

        #region Abilitazione Disabilitazione Interfaccia
        private delegate void AbilitaInterfacciaDelegate();
        /// <summary>
        /// Dopo la connessione abilito l'interfaccia utente che può quindi mandare dei messaggi
        /// </summary>
        private void AbilitaInterfaccia()
        {
            if (this.InvokeRequired)
            {
                IAsyncResult r = this.BeginInvoke(new AbilitaInterfacciaDelegate(AbilitaInterfaccia));
                EndInvoke(r);
            }
            else
            {
                this.connettiToolStripMenuItem.Enabled = false;
                this.disconnettiToolStripMenuItem.Enabled = true;
                this.textBox1.Enabled = true;
                if (this.pictureBox1.Image != null)
                    this.pictureBox1.Image.Dispose();
            }
        }
        delegate void DisabilitaInterfacciaDelegate(string msg_err);
        /// <summary>
        /// Disabilita l'interfaccia utente
        /// </summary>
        /// <param name="msg_err"></param>
        private void DisabilitaInterfaccia(string msg_err)
        {
            if (this.InvokeRequired)
            {
               IAsyncResult r =  BeginInvoke(new DisabilitaInterfacciaDelegate(DisabilitaInterfaccia),msg_err);
               EndInvoke(r);
            }
            else
            {
                if (msg_err != "")
                {
                    MessageBox.Show(msg_err);
                }

                this.connettiToolStripMenuItem.Enabled = true;
                this.disconnettiToolStripMenuItem.Enabled = false;

                if (this.pictureBox1.Image != null)
                    this.pictureBox1.Image.Dispose();
                this.pictureBox1.SizeMode = PictureBoxSizeMode.CenterImage;
                this.pictureBox1.Image = Properties.Resources.attention;
                this.textBox1.Enabled = false;
            }
        }
        #endregion

        #region Aggiorna Chat
        delegate void MyDelegate(string a, string b);
        private void AggiornaChat(string p, string p_2)
        {
            if (this.InvokeRequired)
            {
                IAsyncResult r = BeginInvoke(new MyDelegate(AggiornaChat),new object[] { p, p_2 });
                EndInvoke(r);
            }
            else
            {
                if (p == "Admin")
                {
                    string previous = this.ChatBrowser.Document.Body.InnerHtml;
                    string formattata =
                       "<p font-color:red> <b><i>" + p + ": </b> </i>" +
                        p_2 + "</p>";
                    this.ChatBrowser.Document.Body.InnerHtml = previous + formattata;
                }
                else if (p == "io")
                {
                    string previous = this.ChatBrowser.Document.Body.InnerHtml;
                    string formattata =
                   "<div class=\"chat-bubble2\">" +
                       "<p> <b><i>" + p + ": </b> </i>" +
                        p_2 + "</p>" +
                       "</div>" +
                   "</div>";
                    this.ChatBrowser.Document.Body.InnerHtml = previous + formattata;
                }
                else
                {
                    string previous = this.ChatBrowser.Document.Body.InnerHtml;
                    string formattata =
                   "<div class=\"chat-bubble\">" +
                       "<p> <b><i>" + p + ": </b> </i>" +
                        p_2 + "</p>" +
                        //"<div class=\"chat-bubble-arrow-border\"></div>" +
                        //"<div class=\"chat-bubble-arrow\"></div>" +
                       "</div>" +
                   "</div>";
                    this.ChatBrowser.Document.Body.InnerHtml = previous + formattata;
                }
                this.ChatBrowser.Document.Body.ScrollIntoView(false);
            }
        }

        #endregion

        #region Gestione Controlli Utente

        /// <summary>
        /// Funzione che gestisce il dialogo per richiesta dei dati all'utente
        /// </summary>
        private void ConnectionButton()
        {
            DialogUserPass userpass = new DialogUserPass(); // creo un dialogo 
            if (userpass.ShowDialog() == DialogResult.OK) //aspetto che l'utente abbia inserito tutti i campi
            {
                this.chat_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                this.username = userpass.Username;
                this.password = userpass.PassWord;
                this.indirizzo = userpass.Indirizzo;
                this.porta = userpass.Porta;
                userpass.Dispose();
                try
                {
                    System.Threading.Thread t = new System.Threading.Thread(new System.Threading.ThreadStart(this.connetti));
                    t.Start();
                    this.progressform.Show(this);
                    this.progressform.Location = this.Location;
                    this.Enabled = false;
                }
                catch (SocketException)
                {
                    //MessageBox.Show("Errore di connessione");
                    this.DisabilitaInterfaccia("Errrore di connessione");
                }
            }
            else // l'utente ha chiuso il dialogo
            {
                this.DisabilitaInterfaccia("");
            }
        }

        /// <summary>
        /// Gestisci l'invio del contenuto della textBox
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                Messaggio m = new Messaggio(this.username, this.textBox1.Text);
                invia_msg(m);
                AggiornaChat("io", m.Text);
                this.textBox1.Text = "";
                
            }
            catch (SocketException)
            {
                DisabilitaInterfaccia("Errore connessione");
            }
        }

        /// <summary>
        /// Invia il comando al server di inviare la clipboard condivisa
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void downloadCLipboradToolStripMenuItem_Click(object sender, EventArgs e)
        {
            invia_msg(Messaggio.DownloadClipBoardMessage(this.username));
            AggiornaChat("Admin","Inizio download contenuto clipboard");
        }

        /// <summary>
        /// Gestisce i vari modi di visualizzazione della PictureBox
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void CambioVisualizzazione(object sender, EventArgs e)
        {
            if (VisualizzazioneComboBox.SelectedItem.Equals("Zoom"))
                this.pictureBox1.SizeMode = PictureBoxSizeMode.Zoom;
            if (VisualizzazioneComboBox.SelectedItem.Equals("Normal"))
                this.pictureBox1.SizeMode = PictureBoxSizeMode.Normal;
            if (VisualizzazioneComboBox.SelectedItem.Equals("Strech"))
                this.pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
            if (VisualizzazioneComboBox.SelectedItem.Equals("Center"))
                this.pictureBox1.SizeMode = PictureBoxSizeMode.CenterImage;
        }

        private void toolStripButton1_Click(object sender, EventArgs e)
        {
            if (splitContainer1.Panel1Collapsed == true)
            {
                this.toolStripButton1.Image = Properties.Resources.collapse_left;
                splitContainer1.Panel1Collapsed = false;
            }
            else
            {
                this.toolStripButton1.Image = Properties.Resources.collapse_right;
                splitContainer1.Panel1Collapsed = true;
            }
        }

        private void abilita_pulsante(object sender, EventArgs e)
        {
            if (this.textBox1.Text == "")
                button1.Enabled = false;
            else
                button1.Enabled = true;
        }

        private void PremutoInvio(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == (Char) Keys.Enter)
            {
                this.button1_Click(null, null);
                e.Handled = true;
            }
        }


        private void connettiToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if(this.textBox1.Enabled == false)
                ConnectionButton();
        }

        private void disconnettiToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this.chat_socket.Close();
        }

        private void esciToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this.Close();
        }
        #endregion

        private void salvaConversazioneToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SaveFileDialog dialog = new SaveFileDialog();
            dialog.AddExtension = true;
            dialog.DefaultExt = "html";
            if (dialog.ShowDialog() == DialogResult.OK)
            {
                Stream fs = dialog.OpenFile();
                StreamWriter sw = new StreamWriter(fs);
                sw.WriteLine(this.ChatBrowser.Document.Body.InnerHtml);
                sw.Close();
                fs.Close();
            }
        }

    }
}
